#include <iostream>
#include<fstream>
#include<string.h>

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

using namespace std;
const int MaxSize = 26;
const int MaxSize1 = 27;

//存储单词的结构体
struct Node
{
	string data;       //单词
	string meaning;    //中文意思
	Node* next;
};

//哈希表
class HashTable
{
public:
	HashTable();                               //构造函数
	~HashTable();                              //析构函数
	void show_window();                        //显示窗口函数  
	
private:
	Node* ht[MaxSize][MaxSize1][MaxSize1];

	void Search_words();                       //查找单词函数
	void Insert_words();                       //插入单词函数
	void Delete_words();                       //删除单词函数
	
	int Insert(string str1, string str2);      //插入和读取文件时使用的函数
	int Insert_1(string str1, string str2);    //插入单词时使用的函数
	int isEnglish(string str);                 //判断是否为单词的函数
	int notSpace(string str);                  //判断字符串是否有空格的函数
	Node* Search_1(string str);                //查找单词使用的函数
	void Print();                              //打印哈希表的函数
	int Delete(string str);                    //删除单词使用的函数
	void ReadFile();                           //读取文件函数
	void Menu();                               //主菜单函数
	int H(int k);                              //哈希表函数

};


HashTable::HashTable()  //构造函数
{

	for (int i = 0; i < 26; i++)
	{
		for (int j = 0; j < 27; j++)
		{
			for (int z = 0; z < 27; z++)
			{
				//初始化哈希表
				ht[i][j][z] = NULL;
			}
		}
	}
}

HashTable::~HashTable()  //析构函数
{
	
}

void HashTable::show_window()  //显示窗口函数
{

	system("color F8");

	//将26个单词文件的单词读取进哈希表
	ReadFile();

	int d = 0;
	string sd;
	int flag_menu = 0;

	while (1) 
	{
		system("cls");

		//显示主菜单
		Menu();

		/*
		 *如果flag_menu等于0，就输出第一句
		 * 当选择错误时，输出第二句
		 * 输出第二句后，需要把flag_menu=0
		 * 保证下次显示主菜单时，能显示第一句
		*/ 
		if (flag_menu == 0) 
		{

			cout << "\n\n\t\t\t\t请输入您的选项:";
		}
		else 
		{

			cout << "\n\n\t\t\t!!!!!操作错误，请重新选择<1-4>:";
			flag_menu = 0;
		}

		//输入选择
		getline(cin, sd);

		//获取输入的字符串的第一个字符
		char c = sd[0];

		//获取输入字符串的长度
		int c1 = sd.length();

		//将字符转化成整型
		d = c;

		/*
		 * 当输入字符长度为1且d等于'1'时，执行查找单词操作；
		 * 当输入字符长度为1且d等于'2'时，执行插入单词操作；
		 * 当输入字符长度为1且d等于'3'时，执行删除单词操作；
		 * 当输入字符长度为1且d等于'4'时，执行退出操作；
		 * 其他情况，提醒操作错误，并重新操作；
		*/
		if (d == 49 && c1 == 1) 
		{
			//查找单词
			Search_words();
		}
		else if (d == 50 && c1 == 1) 
		{
			//插入单词
			Insert_words();
		}
		else if (d == 51 && c1 == 1) 
		{
			//删除单词
			Delete_words();
		}
		else if (d == 52 && c1 == 1) 
		{
			//退出系统
			exit(1);
		}
		else 
		{
			//操作错误，flag_menu=1;即显示错误和重新选择语句
			flag_menu = 1;
		}

	}
}

void HashTable::Search_words()  //查找单词函数
{
	int flag1 = 0,flag =0;
	string str,sd;
	char c;

	while (1)
	{
		system("cls");

		cout << "\n\n\n\n\t\t\t<<=================查询界面=================>>\n";

		/*
		  * 当flag1等于0时，输出第一句
		  * 当flag1!=0时，表示输入单词有误，显示第二句；
		*/
		if (flag1 == 0) 
		{
			cout << "\n\n\t\t\t\t*输入查询的单词：";
		}
		else 
		{
			//输入单词有误提示语句
			cout << "\n\n\t\t\t！！！输入不是单词，重新输入：";
		}

		/*
		  * 当flag=0时，输入单词，
		  * 当flag!=0时，表示输入单词意思时有误，
		  * 但是单词正确，单词不需要输入了
		*/
		if (flag == 0) 
		{
			//输入单词
			getline(cin, str);

			//判断单词是否正确，即是否为字母构成的字符串
			int DD = isEnglish(str);

			//DD=0,表示输入的单词有问题
			if (DD == 0) 
			{

				//flag1=1:表示单词输入有误，待会打印出来
				flag1 = 1;

				//结束本次循环，重新输入单词，并根据flag=1,输出上次输入有误
				continue;
			}
		}

		system("cls");

		cout << "\n\n\n\n\t\t\t<<=================查询结果=================>>\n";

		//查询哈希表中是否有str
		Node* p = Search_1(str);

		/*
		* 如果p=nullptr时，表示哈希表中没有str;
		* 如果p!=nullptr时，输出查询的单词的意思
		*/
		if (p == NULL) 
		{
			cout << "\n\n\t\t\t\t*没有：" << str << endl;	
		}
		else 
		{
			cout << "\n\t\t\t\t* " << str << " ---- " << p->meaning << endl;
		}

		//显示操作菜单
		cout << "\n\n\t\t\t\t<<------操作菜单------->>" << endl;
		cout << "\n\t\t\t\t 【1】---返回主菜单" << endl;
		cout << "\t\t\t\t 【2】---继续查找" << endl;

		/*
		 * 如果flag=0时,输出第一句
		 * 如果flag!=0时，表示操作错误，重新输入
		*/
		if (flag == 0) 
		{
			cout << "\n\t\t\t\t **你的操作："; 
		}
		else
		{
			//操作错误，重新输入
			cout << "\n\t\t\t！！！！！操作错误,重新选择（1/2）：";			
		}

		//输入操作
		getline(cin, sd);

		//获取字符串的第一个字符
		c = sd[0];

		//字符串的长度
		int LEN = sd.length();

		//字符转化成整型
		int d = c;

		/*
		  * 当d=49&&LEN=1时，返回主菜单
		  * 当d=50&&LEN=1时，继续查找
		  * 其他情况，表示操作错误
		*/
		if (d == 49 && LEN == 1) 
		{
	        //退出循环，将要显示主菜单
			break;
		}
		else if (d == 50 && LEN == 1) 
		{
			//继续查找，为了下次提示输入单词时，输出第一句
			flag1 = 0;

			//保证下次操作时，输入第一句
			flag = 0;
			continue;
		}
		else 
		{
			//flag置1：表示操作错误
			flag = 1;
		}
	}
}

void HashTable::Insert_words()  //插入单词函数
{
	int flag = 0, flag1 = 0, flag2 = 0;
	int DD = 0;
	char c;
	string str;
	string meaning;

	while (1)
	{
		system("cls");

		cout << "\n\n\n\n\t\t\t<<=================插入界面=================>>\n";

		/*
		* flag1=0,输出首次输入时的提示
		* flag1!=0,输出：重新输入的提示
		*/
		if (flag1 == 0) 
		{
			cout << "\n\n\t\t\t\t*输入插入的单词：";
		}
		else 
		{
			cout << "\n\n\t\t\t\t!!!!!请输入正确的单词：";
		}

		//输入单词
		getline(cin, str);

		//判断str是否是单词
		int DS = isEnglish(str);

		if (DS == 0) 
		{
			//flag1=1：表示输入的不是单词
			flag1 = 1;
			//结束本次循环，重新输入单词
			continue;
		}

		//判断str是否在哈希表中
		Node* P = Search_1(str);

		//如果p!=nullptr,表示str哈希表有
		//如果p=nullptr,接着输入str的意思，并存入哈希表
		if (P != NULL) 
		{
			cout << "\n\n\t\t\t\t##  " + str + " :已经插入 ##" << endl;
		}
		else 
		{
			while (1) 
			{
				//flag2=0,表示首次输入中文意思
				if (flag2 == 0) 
				{
					cout << "\n\n\t\t\t\t*插入单词的意思：";
					getline(cin, meaning);
				}
				
				//判断meaning中是否有空格
				//如果meaning没空格，则退出循环，插入哈希表
				if (notSpace(meaning) == 1) 
				{
					break;
				}
				else 
				{
					//flag2 = 1；做个标记，提示输入意思这语句不用输出
					flag2 = 1;
					system("cls");

					cout << "\n\n\n\n\t\t\t<<=================插入界面=================>>\n";
					cout << "\n\n\t\t\t !!!!!请输入" + str + " 正确的单词意思：";

					//输入单词的意思
					getline(cin, meaning);
				}
			}

			system("cls");

			cout << "\n\n\n\n\t\t\t<<=================插入结果=================>>\n";

			//将str和meanig输入哈希表
			DD = Insert_1(str, meaning);

			//DD=-1,表示没插入成功
			//DD= 1,表示插入成功
			if (DD == -1) 
			{
				cout << "\n\n\t\t\t\t$$  " + str + " :没插入成功 $$" << endl;
			}
			else 
			{
				cout << "\n\n\t\t\t\t***  " + str + " :插入成功 ***" << endl;
			}
		}

		int flag3 = 0;

		while (1)
		{
			string sD;

			//flag!=0:输出操作错误提示
			if (flag != 0) 
			{
				system("cls");
				cout << "\n\n\n\n\t\t\t！！！！！！！！！操作错误！！！！！！！！！！！\n";
			}

			cout << "\n\n\t\t\t\t<<------操作菜单------->>" << endl;
			cout << "\n\t\t\t\t 【1】---返回主菜单" << endl;
			cout << "\t\t\t\t 【2】---继续查找" << endl;

			//flag=0:表示首次提示输入操作
			//flag!=0:表示操作错误提示
			if (flag == 0) 
			{
				cout << "\n\t\t\t\t **你的操作："; 
			}
			else
			{
				cout << "\n\t\t\t！！！！！操作错误,重新选择（1/2）：";	
			}

			//读取操作
			getline(cin, sD);

			c = sD[0];
			int le = sD.length();
			int d = c;

			if (d == 49 && le == 1) 
			{
				//标记要返回主菜单
				flag3 = 1;
				break;
			}
			else if (d == 50 && le == 1) 
			{
				//继续插入
				flag2 = 0;
				flag1 = 0;
				break;
			}
			else {

				//操作错误
				flag = 1;
			}
		}

		//退出循环，返回主菜单
		if (flag3 != 0) 
		{
			break;
		}
	}
}

void HashTable::Delete_words()  //删除单词函数
{
	int flag1 = 0, flag = 0;
	string str,sd;
	char c;

	while (1)
	{

		system("cls");

		cout << "\n\n\n\n\t\t\t<<=================删除界面=================>>\n";

        //flag1=0:表示首次提示输入删除的单词
		if (flag1 == 0) 
		{
			cout << "\n\n\t\t\t\t*输入删除的单词：";
		}
		else 
		{
			cout << "\n\n\t\t\t！！！输入不是单词，重新输入：";
		}

		if (flag == 0) 
		{
			//读取输入的单词
			getline(cin, str);

			//判断是否为单词
			int DD = isEnglish(str);

			if (DD == 0) 
			{
				//提示输入不是单词，重新输入
				flag1 = 1;

				//结束本次循环，重新输入
				continue;
			}
		}

		system("cls");

		cout << "\n\n\n\n\t\t\t<<=================删除结果=================>>\n";

		//删除
		int dd = Delete(str);

		/*
		*判断是否成功删除
		* dd=1,删除成功
		* dd=0,不存在str
		* dd=-1，为成功删除
		*/
		if (dd == 1) 
		{
			cout << "\n\n\t\t\t\t***  " + str + " :删除成功 ***" << endl;
		}
		else if (dd == 0) 
		{
			cout << "\n\n\t\t\t\t###  " + str + " :不存在 ###" << endl;
		}
		else 
		{
			cout << "\n\n\t\t\t\t!!!  " + str + "未删除成功 !!!" << endl;
		}

		cout << "\n\n\t\t\t\t<<------操作菜单------->>" << endl;
		cout << "\n\t\t\t\t 【1】---返回主菜单" << endl;
		cout << "\t\t\t\t 【2】---继续删除" << endl;

		//flag=0,首次提示输入操作
		//flag!=0.操作错误提示
		if (flag == 0) 
		{
			cout << "\n\t\t\t\t **你的操作："; 
		}
		else
		{
			cout << "\n\t\t\t！！！！！操作错误,重新选择（1/2）：";			
		}

		//读取操作的字符串
		getline(cin, sd);

		//获取字符串的首个字符
		c = sd[0];

		//获取字符串的长度
		int LEN = sd.length();

		//字符型转整型
		int d = c;

		if (d == 49 && LEN == 1) 
		{
			//返回主菜单
			break;
		}
		else if (d == 50 && LEN == 1) 
		{
			//继续删除
			flag1 = 0;
			flag = 0;
			continue;
		}
		else 
		{
			//操作错误
			flag = 1;
		}
	}
}


int HashTable::Insert(string str1, string str2) //插入和读取文件时使用的函数
{
	//获取字符串的长度
	int len = str1.length();
	//定义一个长度为3的整型数组，分别存储关键码的三个数字
	int a[3];

	//默认后两位为0
	a[1] = 0;
	a[2] = 0;

	/*
	* 数组的第一位存储字符串的第一字符+7的和取模的值
	* 数组的第二位存储字符串的第二字符+7的和取模的值
	* 数组的第三位存储字符串的第三字符+7的和取模的值
	* 
	* 如果字符串长度1，后两个数组为0，
	* 如果字符串长度2，后一个数组为0，
	* 如果字符串长度3以上，采用拉链发
	* 所以字符两位以上的，取模后都要加1
	*/
	for (int i = 0; i < len && i < 3; i++)
	{
		a[i] = H(str1[i] + 7);

		if (i == 1) 
		{
			a[1] = a[1] + 1;
		}
		if (i == 2) 
		{
			a[2] = a[2] + 1;
		}
	}


	//查找哈希表中是否存在str1;
	Node* p = Search_1(str1);

	/*
	* 插入分以下几种情况
	* 1---长度为2和1的直接插入
	* 2 -- 长度为3以上的分以下几种情况
	*     2-1：原来没有，则直接插入
	*     2-2：原来有，先与首位比较，则又分以下几种情况：
	*          2-2-1：插入的比原来首位的小，则头插
	*          2-2-1：插入的比原来首位的大，则尾插
	*     2-3：需要找到合适位置，再插入      
	*/

	if (p != NULL) 
	{
		//存在，直接返回
		return -1;
	}
	else if (p == NULL && (len == 2 || len == 1)) 
	{
		//哈希表中不存在其字符串长为2--直接插入
		p = new Node;
		p->data = str1;
		p->meaning = str2;
		p->next = NULL;
		ht[a[0]][a[1]][0] = p;
		return 1;
	}
	else if (p == NULL && len >= 3) 
	{
		//哈希表中不存在其字符串长为2--拉链法 
		p = new Node;
		p->data = str1;
		p->meaning = str2;
		p->next = NULL;

		//根据字母顺序排列插入
		Node* pre = ht[a[0]][a[1]][a[2]];

		if (pre == NULL) 
		{
			//直接插入
			ht[a[0]][a[1]][a[2]] = p;
			return 1;
		}

		Node* last = pre->next;

		//strcmp的参数类型为const char,所以需要转换
		const char* s1;
		const char* s2 = str1.c_str();

		//如果插入的比原来排在首位的都要小，就直接插入
		if (strcmp(s1 = pre->data.c_str(), s2) > 0) 
		{
			p->next = pre;
			ht[a[0]][a[1]][a[2]] = p;
			return 1;
		}
		else
		{

			//如果插入的比原来排在首位的都要大，需要先找位置
			if (last == NULL) 
			{
				//原来里面只有一个，而且要插入的排在后面，则直接插入
				pre->next = p;
				return 1;
			}

			//找位置
			while (last != NULL)
			{
				s1 = last->data.c_str();
				if (strcmp(s1, s2) > 0) 
				{
					break;
				}

				last = last->next;
				pre = pre->next;
			}

			//找到位置后插入
			p->next = pre->next;
			pre->next = p;
			return 1;
		}

	}

}


int HashTable::Insert_1(string str1, string str2)  //插入单词时使用的函数
{
	//查找是否存在str1
	Node* p = Search_1(str1);

	if (p != NULL) 
	{
		//存在直接返回
		return 0;
	}
	else
	{
		//插入
		int f = Insert(str1, str2);

		if(f==0)
		{
			//插入不成功，直接返回
			return -1;
		}

		//获取单词第一个字符
		char ch = str1[0];

		//单词第一个字符和".txt"拼成一个文件路径
		string SS = "";
		SS.append(1, ch);
		SS.append(".txt");

		//将插入后的哈希表读入相对应的文件
		const char *SSS = SS.c_str();
		ofstream outfile(SSS, ios::out);
			
		Node* p = NULL;

	    //以下步骤是将哈希表中单词以ch字符开头的，按照顺序读入文件
		int I = H(ch + 7);

		//先写单词长度为1的单词
		if ((p = ht[I][0][0]) != NULL) 
		{
			outfile << p->data << "  " << p->meaning << endl;
		}
		
		for (int j = 'a'; j <= 'z'; j++)	
		{
			int J = H(j + 7) + 1;

			//接着写长度为2的
			if ((p = ht[I][J][0]) != NULL) 
			{
				outfile << p->data << "  " << p->meaning << endl;
			}

			for (int z = 'a'; z <= 'z'; z++)
			{
				int Z = H(z + 7) + 1;
				p = ht[I][J][Z];

				while (p != NULL)
				{
					//最后写长度3以上的
					outfile << p->data << "  " << p->meaning << endl;
					p = p->next;
				}
			}
		}

	}
	return 1;
}

int HashTable::isEnglish(string str)  //判断是否为单词的函数
{
	int length = str.length(), len = 0;

	for (int i = 0; i < length; i++)
	{
		//判断str[i]是否是字母
		if (str[i] >= 'a' && str[i] <= 'z' || str[i] >= 'A' && str[i] <= 'Z') 
		{
			len++;
		}
	}

	//判断字符串str上是否全是字母
	if (len == length)
	{
		return 1;
	}

	return 0;
}


int HashTable::notSpace(string str) //判断字符串是否有空格的函数
{
	int length = str.length(), len = 0;

	for (int i = 0; i < length; i++)
	{
		//字符串中一个一个字符的判断是否为空字符
		if (str[i]!=' ') 
		{
			len++;
		}
	}

	//是否存在空字符
	if (len == length) 
	{
		return 1;
	}

	return 0;
}

Node* HashTable::Search_1(string str) //查找单词使用的函数
{
	//字符的长度
	int len = str.length();

	//定义一个长度为3的整型数组，分别存储关键码的三个数字
	int a[3];

	//默认后两位为0
	a[1] = 0;
	a[2] = 0;

	/*
	* 数组的第一位存储字符串的第一字符+7的和取模的值
	* 数组的第二位存储字符串的第二字符+7的和取模的值
	* 数组的第三位存储字符串的第三字符+7的和取模的值
	*
	* 如果字符串长度1，后两个数组为0，
	* 如果字符串长度2，后一个数组为0，
	* 如果字符串长度3以上，采用拉链发
	* 所以字符两位以上的，取模后都要加1
	*/
	for (int i = 0; i < len&&i<3; i++)
	{	
			a[i] = H(str[i]+7);	

			if (i == 1) 
			{
				a[1] = a[1] + 1;
			}

			if (i == 2) 
			{
				a[2] = a[2] + 1;
			}
	}


	Node* p = ht[a[0]][a[1]][a[2]];

	while (p != NULL)
	{
		//如果相等，则返回p结点
		if (p->data == str) 
		{
			return p;
		}
		else 
		{
			p = p->next;
		}
	}

	//没有则，返回nulllptr
	return NULL;
}

void HashTable::Print() //打印哈希表的函数(题目不要求的函数)
{
	Node* p = NULL;
	int d = 0;
	
	for (int i = 'a'; i <= 'z'; i++)
	{
		int I = H(i + 7);
		if ((p = ht[I][0][0]) != NULL) 
		{
			d++;
			cout << d << " " << p->data << " :" << p->meaning << endl;
		}

		for (int j = 'a'; j <= 'z'; j++)
		{
			
			int J = H(j+7)+1;
			
			if ((p = ht[I][J][0]) != NULL) 
			{
				d++;
				cout << d << " " << p->data << " :" << p->meaning << endl;
			}

			for (int z = 'a'; z <= 'z'; z++)
			{
			
				int Z = H(z+7)+1;	
				p = ht[I][J][Z];
				while (p != NULL)
				{
					d++;
					cout << d << " "<< p->data << " :" << p->meaning << endl;
					p = p->next;
				}
			}
		}
	}
}


int HashTable::Delete(string str)  //删除单词使用的函数
{
	//查找str
	Node* p = Search_1(str);
	if (p == NULL) 
	{
		//不存在，没法删除，直接返回
		return 0;
	}

	int len = str.length();
	int a[3];
	a[1] = 0;
	a[2] = 0;

	for (int i = 0; i < len && i < 3; i++)
	{
		a[i] = H(str[i] + 7);

		if (i == 1) 
		{
			a[1] = a[1] + 1;
		}
		if (i == 2) 
		{
			a[2] = a[2] + 1;
		}
	}
	
    Node *pre = ht[a[0]][a[1]][a[2]],*pp = pre->next;

	/*
	* 删除分以下两种情况：
	* 1--删除的在表头
	* 2--先找到要删除的单词的位置
	*/
	if (strcmp(pre->data.c_str(), str.c_str()) == 0) 
	{
		//删除的在表头
		ht[a[0]][a[1]][a[2]] = pre->next;
		delete pre;
		pre = Search_1(str);
	}
	else
	{
		//先找到要删除的单词的位置
		while (pp != NULL)
		{
			if (pp == p) 
			{
				break;
			}

			pre = pre->next;
			pp = pp->next;	
		}

		pre->next = pp->next;
		delete pp;
	}

	//再次判断哈希表中是否还存在str
	pre = Search_1(str);

	//pre=nullptr表示不存在，更新文件
	if (pre == NULL) {
		
		//获取字符串的第一个字符
		char ch = str[0];

		//字符串首个字符+".txt"拼成的字符串为文件的地址
		string SS = "";
		SS.append(1, ch);
		SS.append(".txt");

		//更新文件
		const char *SSS = SS.c_str(); 
		ofstream outfile(SSS, ios::out);

		Node* p = NULL;
		
			int I = H(ch + 7);

			if ((p = ht[I][0][0]) != NULL) 
			{	
				//先写长度为1的单词进文件
				outfile << p->data << "  " << p->meaning << endl;
			}

			for (int j = 'a'; j <= 'z'; j++)
			{
				int J = H(j + 7) + 1;

				if ((p = ht[I][J][0]) != NULL) 
				{
					//再写长度为2的单词进文件
					outfile << p->data << "  " << p->meaning << endl;
				}

				for (int z = 'a'; z <= 'z'; z++)
				{

					int Z = H(z + 7) + 1;

					p = ht[I][J][Z];
					while (p != NULL)
					{
						//最后读长度3以上的单词进文件
						outfile << p->data << "  " << p->meaning << endl;
						p = p->next;
					}
				}
			}

			//删除成功
			return 1;
	}
	else
	{
		//删除失败
		return -1;
	}	
}


void HashTable::ReadFile() //读取文件函数
{
	int d = 0;
	//将存储单词26个文件的单词读入哈希表
	for (int i = 'a'; i <= 'z'; i++)
	{
		string SS = "";
		char ch =(char)i;

		//字符ch+".txt"拼成的字符串为文件的地址
		SS.append(1,ch);
		SS.append(".txt");
		const char *SSS = SS.c_str();
		
		ifstream infile(SSS, ios::in);

		if (!infile) 
		{
			//SS文件不存在
			cout << SS << "open error" << endl;
			continue;
		}

		char* cha[100];
		string str2, str1, str3;
		char word[100];
		
		//读取完文件中的单词，一行一行读取
		while (!infile.eof())
		{
			//读取一行
			getline(infile, str2);

			//读取到""就结束，因为文件末尾可能会再读取一次
			if (str2 == "") 
			{
				break;
			}

			//将读取一行得到的字符串按照中间的空格分成两个字符串
			strcpy(word, str2.c_str());
			str1 = strtok(word, "  ");
			str3 = strtok(NULL, "  ");

		    //将读取的单词和意思存到哈希表中
			int D = Insert(str1, str3);

			//判断是否插入并打印出来
			if (D == -1) 
			{
				cout << str1 << "已经插入" << endl;
			}
			else if (D == 1) 
			{
				cout << ++d << ":" << str1 << "插入成功" << endl;
			}		
		}
	}
}

void HashTable::Menu()  //主菜单函数
{
	cout << endl;
	cout << endl;
	cout << endl;
	cout << "\t\t\t\t*****************************************" << endl;
	cout << "\t\t\t\t*                                       *" << endl;
	cout << "\t\t\t\t*===========欢迎使用英汉词典============*" << endl;
	cout << "\t\t\t\t*                                       *" << endl;
	cout << "\t\t\t\t*            1    查找单词              *" << endl;
	cout << "\t\t\t\t*            2    插入单词              *" << endl;
	cout << "\t\t\t\t*            3    删除单词              *" << endl;
	cout << "\t\t\t\t*            4    退出词典              *" << endl;
	cout << "\t\t\t\t*                                       *" << endl;
	cout << "\t\t\t\t*           按回车键返回主菜单          *" << endl;
	cout << "\t\t\t\t*****************************************" << endl;

}

int HashTable::H(int k) //哈希表函数
{
	//哈希表长度为26，26取模
	int d = k % 26;

	return d;
}

int main(int argc, char* argv[])
{
	HashTable HT;

	//显示窗口
	HT.show_window();

	return 0;
}
